{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xjgDyfmL6hB_"
   },
   "source": [
    "<center>\n",
    "    <p style=\"text-align:center\">\n",
    "        <img alt=\"phoenix logo\" src=\"https://storage.googleapis.com/arize-assets/phoenix/assets/phoenix-logo-light.svg\" width=\"200\"/>\n",
    "        <br>\n",
    "        <a href=\"https://arize.com/docs/phoenix/\">Docs</a>\n",
    "        |\n",
    "        <a href=\"https://github.com/Arize-ai/phoenix\">GitHub</a>\n",
    "        |\n",
    "        <a href=\"https://arize-ai.slack.com/join/shared_invite/zt-2w57bhem8-hq24MB6u7yE_ZF_ilOYSBw#/shared-invite/email\">Community</a>\n",
    "    </p>\n",
    "</center>\n",
    "<h1 align=\"center\">Code Functionality  Evals</h1>\n",
    "\n",
    "\n",
    "This tests whether code is written correctly, without bugs, accomplishes the functionality you want, does not have syntax errors.\n",
    "\n",
    "The purpose of this notebook is:\n",
    "\n",
    "- to evaluate the performance of code fuctionality Eval\n",
    "- to provide an experimental framework for users to iterate and improve on the default classification template.\n",
    "\n",
    "## Install Dependencies and Import Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "R8pDe5eG6hCJ",
    "outputId": "724b67f8-9d0f-41cd-f212-570d2484c5a0"
   },
   "outputs": [],
   "source": [
    "!pip install -qq arize-phoenix  \"openai>=1\" ipython matplotlib pycm scikit-learn tiktoken nest_asyncio 'httpx<0.28'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "h2ctpohg6hCK"
   },
   "source": [
    "ℹ️ To enable async request submission in notebook environments like Jupyter or Google Colab, optionally use `nest_asyncio`. `nest_asyncio` globally patches `asyncio` to enable event loops to be re-entrant. This is not required for non-notebook environments.\n",
    "\n",
    "Without `nest_asyncio`, eval submission can be much slower, depending on your organization's rate limits. Speed increases of about 5x are typical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "WHnAJf1g6hCL"
   },
   "outputs": [],
   "source": [
    "import nest_asyncio\n",
    "\n",
    "nest_asyncio.apply()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "0bNZhOO46hCL",
    "outputId": "1980d240-5319-4d13-ea10-e2d745920d14"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "from getpass import getpass\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from pycm import ConfusionMatrix\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "from phoenix.evals import (\n",
    "    CODE_FUNCTIONALITY_PROMPT_RAILS_MAP,\n",
    "    # To Add templates\n",
    "    CODE_FUNCTIONALITY_PROMPT_TEMPLATE,\n",
    "    OpenAIModel,\n",
    "    llm_classify,\n",
    ")\n",
    "\n",
    "pd.set_option(\"display.max_colwidth\", None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mvrJ8sQK6hCM"
   },
   "source": [
    "## Download Benchmark Dataset\n",
    "\n",
    "TODO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 536
    },
    "id": "o-BbInt76hCN",
    "outputId": "b87d1f6f-8bbf-419e-fb19-61c9297caa06"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>coding_instruction</th>\n",
       "      <th>code</th>\n",
       "      <th>is_well_coded</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Create a neural network in Python from scratch that takes a 2D array of numbers as its input and predicts the sum of the numbers in each row.</td>\n",
       "      <td>import numpy as np\\n\\nclass NeuralNetwork:\\n    def __init__(self, input_size):\\n        self.weights = np.random.rand(input_size, 1)\\n        self.bias = np.random.rand(1, 1)\\n\\n    def predict(self, X):\\n        return np.dot(X, self.weights) + self.bias\\n\\n# Example Usage:\\ninput_data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\\nnn = NeuralNetwork(input_size=input_data.shape[1])\\npredictions = nn.predict(input_data)\\nprint(predictions)</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Generate a Python program to find the mode of the given list.</td>\n",
       "      <td>from statistics import mode\\n\\ndef find_mode(input_list):\\n    try:\\n        result = mode(input_list)\\n        return result\\n    except StatisticsError:\\n        return \"No unique mode found\"\\n\\n# Example Usage:\\ndata_list = [1, 2, 2, 3, 4, 4, 5]\\nmode_result = find_mode(data_list)\\nprint(mode_result)</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Develop a text summarizer in Python that takes a text input and returns a summary of the text in two sentences.</td>\n",
       "      <td>from nltk import sent_tokenize\\nfrom nltk.corpus import stopwords\\nfrom nltk.stem import PorterStemmer\\nfrom sklearn.feature_extraction.text import TfidfVectorizer\\nfrom sklearn.metrics.pairwise import cosine_similarity\\n\\ndef text_summarizer(text):\\n    sentences = sent_tokenize(text)\\n    stop_words = set(stopwords.words('english'))\\n    vectorizer = TfidfVectorizer()\\n    ps = PorterStemmer()\\n\\n    def preprocess_sentence(sentence):\\n        words = [ps.stem(word) for word in sentence.split() if word.lower() not in stop_words]\\n        return ' '.join(words)\\n\\n    preprocessed_sentences = [preprocess_sentence(sentence) for sentence in sentences]\\n\\n    try:\\n        tfidf_matrix = vectorizer.fit_transform(preprocessed_sentences)\\n        sentence_similarity = cosine_similarity(tfidf_matrix, tfidf_matrix)\\n    except ValueError:\\n        return \"Input text is too short for summarization.\"\\n\\n    sentence_scores = [(index, sum(sentence_similarity[index])) for index in range(len(sentences))]\\n    sentence_scores = sorted(sentence_scores, key=lambda x: x[1], reverse=True)\\n\\n    summary_sentences = [sentences[score[0]] for score in sentence_scores[:2]]\\n    summary = ' '.join(summary_sentences)\\n\\n    return summary\\n\\n# Example Usage:\\ninput_text = \"Your input text goes here. It should be a longer piece of text for meaningful summarization.\"\\nsummary_result = text_summarizer(input_text)\\nprint(summary_result)</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Create a program in Python to generate random passwords of 8 characters.</td>\n",
       "      <td>import random\\nimport string\\n\\ndef generate_random_password():\\n    password_length = 8\\n    characters = string.ascii_letters + string.digits + string.punctuation\\n    password = ''.join(random.choice(characters) for i in range(password_length))\\n    return password\\n\\n# Example Usage:\\nrandom_password = generate_random_password()\\nprint(random_password)</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Design a python program to replace every occurrence of a word in a string with another word.</td>\n",
       "      <td>def replace_word(string, word, replacement_word):\\n    return string.replace(word)\\n\\nprint(replace_word(\"Hello hello world!\", \"hello\", \"welcome\"))</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                                                                                              coding_instruction  \\\n",
       "0  Create a neural network in Python from scratch that takes a 2D array of numbers as its input and predicts the sum of the numbers in each row.   \n",
       "1                                                                                  Generate a Python program to find the mode of the given list.   \n",
       "2                                Develop a text summarizer in Python that takes a text input and returns a summary of the text in two sentences.   \n",
       "3                                                                       Create a program in Python to generate random passwords of 8 characters.   \n",
       "4                                                   Design a python program to replace every occurrence of a word in a string with another word.   \n",
       "\n",
       "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         code  \\\n",
       "0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                import numpy as np\\n\\nclass NeuralNetwork:\\n    def __init__(self, input_size):\\n        self.weights = np.random.rand(input_size, 1)\\n        self.bias = np.random.rand(1, 1)\\n\\n    def predict(self, X):\\n        return np.dot(X, self.weights) + self.bias\\n\\n# Example Usage:\\ninput_data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\\nnn = NeuralNetwork(input_size=input_data.shape[1])\\npredictions = nn.predict(input_data)\\nprint(predictions)   \n",
       "1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            from statistics import mode\\n\\ndef find_mode(input_list):\\n    try:\\n        result = mode(input_list)\\n        return result\\n    except StatisticsError:\\n        return \"No unique mode found\"\\n\\n# Example Usage:\\ndata_list = [1, 2, 2, 3, 4, 4, 5]\\nmode_result = find_mode(data_list)\\nprint(mode_result)   \n",
       "2  from nltk import sent_tokenize\\nfrom nltk.corpus import stopwords\\nfrom nltk.stem import PorterStemmer\\nfrom sklearn.feature_extraction.text import TfidfVectorizer\\nfrom sklearn.metrics.pairwise import cosine_similarity\\n\\ndef text_summarizer(text):\\n    sentences = sent_tokenize(text)\\n    stop_words = set(stopwords.words('english'))\\n    vectorizer = TfidfVectorizer()\\n    ps = PorterStemmer()\\n\\n    def preprocess_sentence(sentence):\\n        words = [ps.stem(word) for word in sentence.split() if word.lower() not in stop_words]\\n        return ' '.join(words)\\n\\n    preprocessed_sentences = [preprocess_sentence(sentence) for sentence in sentences]\\n\\n    try:\\n        tfidf_matrix = vectorizer.fit_transform(preprocessed_sentences)\\n        sentence_similarity = cosine_similarity(tfidf_matrix, tfidf_matrix)\\n    except ValueError:\\n        return \"Input text is too short for summarization.\"\\n\\n    sentence_scores = [(index, sum(sentence_similarity[index])) for index in range(len(sentences))]\\n    sentence_scores = sorted(sentence_scores, key=lambda x: x[1], reverse=True)\\n\\n    summary_sentences = [sentences[score[0]] for score in sentence_scores[:2]]\\n    summary = ' '.join(summary_sentences)\\n\\n    return summary\\n\\n# Example Usage:\\ninput_text = \"Your input text goes here. It should be a longer piece of text for meaningful summarization.\"\\nsummary_result = text_summarizer(input_text)\\nprint(summary_result)   \n",
       "3                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      import random\\nimport string\\n\\ndef generate_random_password():\\n    password_length = 8\\n    characters = string.ascii_letters + string.digits + string.punctuation\\n    password = ''.join(random.choice(characters) for i in range(password_length))\\n    return password\\n\\n# Example Usage:\\nrandom_password = generate_random_password()\\nprint(random_password)   \n",
       "4                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         def replace_word(string, word, replacement_word):\\n    return string.replace(word)\\n\\nprint(replace_word(\"Hello hello world!\", \"hello\", \"welcome\"))   \n",
       "\n",
       "   is_well_coded  \n",
       "0           True  \n",
       "1           True  \n",
       "2           True  \n",
       "3           True  \n",
       "4          False  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv(\n",
    "    \"https://storage.googleapis.com/arize-assets/phoenix/evals/code-functionality/validated_python_code_samples_2.csv\"\n",
    ")\n",
    "\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "khGGD8hN6hCP"
   },
   "source": [
    "\n",
    "\n",
    "```\n",
    "# This is formatted as code\n",
    "```\n",
    "\n",
    "## Display Code Functionality Classification Template\n",
    "\n",
    "View the default template used to code functionality. You can tweak this template and evaluate its performance relative to the default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "BQAEPJJn7vcj"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Code Evaluation Prompt:\n",
      "TEST EDIT\n",
      "-----------------------\n",
      "Evaluate the provided code to determine its correctness in solving the given instruction.\n",
      "\n",
      "Data:\n",
      "-----\n",
      "[Instruction]: {coding_instruction}\n",
      "  Clearly define the task or problem that the code aims to address.\n",
      "\n",
      "[Reference Code]: {code}\n",
      "  Examine the submitted code for evaluation in the context of the provided instruction.\n",
      "\n",
      "Evaluation:\n",
      "-----------\n",
      "Provide a concise response with a single word: either \"bug_free\" or \"is_bug\".\n",
      "- \"bug_free\" signifies that the code correctly and efficiently solves the instruction with no bugs.\n",
      "- \"is_bug\" indicates that the code either fails to meet the instruction requirements or contains bugs.\n",
      "\n",
      "Example:\n",
      "-----------\n",
      "\n",
      "[Instruction]: Implement the Fibonacci sequence in Python.\n",
      "\n",
      "[Reference Code]: 'def fibonacci(n):\n",
      "    if n <= 1:\n",
      "        return n\n",
      "    else:\n",
      "        return fibonacci(n - 1) + fibonacci(n - 2)\n",
      "\n",
      "for i in range(10):\n",
      "    print(fibonacci(i))'\n",
      "\n",
      "[Output]: bug_free\n",
      "\n",
      "Note: Assumptions can be made that any code needed for the instruction is correct, and optimization is not a requirement for a correct solution. Your response should consist solely of the words \"bug_free\" or \"is_bug\" without additional text or characters.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(CODE_FUNCTIONALITY_PROMPT_TEMPLATE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "505OyTtx6hCQ"
   },
   "source": [
    "The template variables are:\n",
    "\n",
    "- **coding_instruction:** What is the code supposed to do as an instruction\n",
    "- **code:** The code to evaluate \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cWTzktuj6hCQ"
   },
   "source": [
    "## Configure the LLM\n",
    "\n",
    "Configure your OpenAI API key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Hq-KlIVH6hCQ",
    "outputId": "3b978aaa-183d-489a-afb8-e37db1cb2110"
   },
   "outputs": [],
   "source": [
    "if not (openai_api_key := os.getenv(\"OPENAI_API_KEY\")):\n",
    "    openai_api_key = getpass(\"🔑 Enter your OpenAI API key: \")\n",
    "os.environ[\"OPENAI_API_KEY\"] = openai_api_key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aNybVoRm6hCR"
   },
   "source": [
    "## Benchmark Dataset Sample\n",
    "Sample size determines run time\n",
    "Recommend iterating small: 100 samples\n",
    "Then increasing to large test set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MSOJ9_2_6hCR"
   },
   "source": [
    "## LLM Evals: Code Functionality Classifications GPT-4\n",
    "Run Code Functionality against a subset of the data.\n",
    "Instantiate the LLM and set parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "rQ4dZYfS6hCS",
    "outputId": "cb3b06db-0170-4ae2-d1ea-1440dcc66922"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The `model_name` field is deprecated. Use `model` instead.                 This will be removed in a future release.\n"
     ]
    }
   ],
   "source": [
    "model = OpenAIModel(\n",
    "    model_name=\"gpt-4\",\n",
    "    temperature=0.0,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "VeNgrhj16hCS",
    "outputId": "d5c76620-cb75-4edb-d37f-afff6b72e75d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Hello! I'm working perfectly. How can I assist you today?\""
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model(\"Hello world, this is a test if you are working?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7oLPjvr36hCT"
   },
   "source": [
    "## Run Code Func Classifications\n",
    "\n",
    "Run code functionality classifications against a subset of the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 49,
     "referenced_widgets": [
      "8763982494d64e97bf50204d4b8beca3",
      "34e87b1773004b83ae4f227a2ec4e504",
      "b5914f9bde894147a126f2552c68212c",
      "a508ddd770e44356a773d94ab8fcf977",
      "bb44d964d93642b9946253033c3d9e94",
      "8b4a5af6f76d431d8570e7400f8086fd",
      "a9933a0bab7f496fa2527f1abd4f2807",
      "2eefae02445a4b1e9aad8fdc47a63572",
      "ca3b583f7f5845f3b0cf197ac1b63976",
      "568d5c22695a4108b3b0c27119cbf97e",
      "f55ce1255e3f4dc6aab23b448a5c7574"
     ]
    },
    "id": "Q2592lfO6hCU",
    "outputId": "5e200b64-d312-4f9a-9c22-7abe4cf96883"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "llm_classify |██████████| 50/50 (100.0%) | ⏳ 00:08<00:00 |  6.20it/s\n"
     ]
    }
   ],
   "source": [
    "# The rails is used to hold the output to specific values based on the template\n",
    "# It will remove text such as \",,,\" or \"...\"\n",
    "# Will ensure the binary value expected from the template is returned\n",
    "rails = list(CODE_FUNCTIONALITY_PROMPT_RAILS_MAP.values())\n",
    "relevance_classifications = llm_classify(\n",
    "    dataframe=df,\n",
    "    template=CODE_FUNCTIONALITY_PROMPT_TEMPLATE,\n",
    "    model=model,\n",
    "    rails=rails,\n",
    "    concurrency=20,\n",
    ")[\"label\"].tolist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ImqyWlGw6hCV"
   },
   "source": [
    "## Evaluate Classifications\n",
    "\n",
    "Evaluate the predictions against human-labeled ground-truth code functionality labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 651
    },
    "id": "8Ls9n2S76hCW",
    "outputId": "d4167fe4-2260-4b92-dd39-0bbe7f921ef3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "    bug_free       0.96      0.81      0.88        31\n",
      "      is_bug       0.75      0.95      0.84        19\n",
      "\n",
      "    accuracy                           0.86        50\n",
      "   macro avg       0.86      0.88      0.86        50\n",
      "weighted avg       0.88      0.86      0.86        50\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Axes: title={'center': 'Confusion Matrix (Normalized)'}, xlabel='Predicted Classes', ylabel='Actual Classes'>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "true_labels = df[\"is_well_coded\"].map(CODE_FUNCTIONALITY_PROMPT_RAILS_MAP).tolist()\n",
    "\n",
    "print(classification_report(true_labels, relevance_classifications, labels=rails))\n",
    "confusion_matrix = ConfusionMatrix(\n",
    "    actual_vector=true_labels, predict_vector=relevance_classifications, classes=rails\n",
    ")\n",
    "confusion_matrix.plot(\n",
    "    cmap=plt.colormaps[\"Blues\"],\n",
    "    number_label=True,\n",
    "    normalized=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "w5ZJV1IC6hCX"
   },
   "source": [
    "## Classifications with explanations\n",
    "\n",
    "When evaluating a dataset for code functionality, it can be useful to know why the LLM classified a document as relevant or irrelevant. The following code block runs `llm_classify` with explanations turned on so that we can inspect why the LLM made the classification it did. There is speed tradeoff since more tokens is being generated but it can be highly informative when troubleshooting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 873,
     "referenced_widgets": [
      "1f7c7ce2ea874835986c9988bc062d82",
      "bb5911202039461b98517aba47f7e656",
      "3357650b34ed48848c6aec68957a9654",
      "5b85cf639b5c4a0cb5e4acff52a58ae8",
      "b5440442ff814c69ab5409ec55b16a4e",
      "0d06c9bac593459e8b4349697b60fd45",
      "5ccf1ab7cc164b6cb0c12b99dbd526e1",
      "6f96f9c08c6742429e31e35b5b5e9c45",
      "861dc30d89d846c6a6f5c1b5398b877c",
      "90253079c26747df99af818a9edabf36",
      "e8071c5ea332447c894cd34bee283ab2"
     ]
    },
    "id": "DwS_xRu-6hCY",
    "outputId": "8b6783fe-6ff3-4a18-e363-a3bc5238bce6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using prompt:\n",
      "\n",
      "\n",
      "Code Evaluation Prompt:\n",
      "-----------------------\n",
      "Evaluate the provided code to determine its correctness in solving the given instruction.\n",
      "\n",
      "Data:\n",
      "-----\n",
      "[Instruction]: {coding_instruction}\n",
      "  Clearly define the task or problem that the code aims to address.\n",
      "\n",
      "[Reference Code]: {code}\n",
      "  Examine the submitted code for evaluation in the context of the provided instruction.\n",
      "\n",
      "Evaluation:\n",
      "-----------\n",
      "Provide a concise response with a explanation and a single word LABEL: either \"bug_free\" or \"is_bug\".\n",
      "- \"bug_free\" signifies that the code correctly and efficiently solves the instruction with no bugs.\n",
      "- \"is_bug\" indicates that the code either fails to meet the instruction requirements or contains bugs.\n",
      "\n",
      "Example:\n",
      "-----------\n",
      "\n",
      "[Instruction]: Implement the Fibonacci sequence in Python.\n",
      "\n",
      "[Reference Code]: 'def fibonacci(n):\n",
      "    if n <= 1:\n",
      "        return n\n",
      "    else:\n",
      "        return fibonacci(n - 1) + fibonacci(n - 2)\n",
      "\n",
      "for i in range(10):\n",
      "    print(fibonacci(i))'\n",
      "\n",
      "[Output]: bug_free\n",
      "\n",
      "Note: Assumptions can be made that any code needed for the instruction is correct, and optimization is not a requirement for a correct solution. Your response should consist solely of the words \"bug_free\" or \"is_bug\" without additional text or characters.\n",
      "\n",
      "Please read the instruction and code carefully, then write out in a step by step manner an EXPLANATION to show how\n",
      "to evaluate the functionality of the code. Avoid simply stating the correct answer at the outset.\n",
      "You are then going to respond with a LABEL (a single word evaluation).\n",
      "If the reference code functionally solves the instruction problem without any bugs than call it \"bug_free\". \n",
      "If reference code has bugs or does not functionally solve the instruction problem than call it \"is_bug\".\n",
      "\n",
      "Example response:\n",
      "************\n",
      "EXPLANATION: An explanation of your reasoning for why the code is bug_free or is_bug\n",
      "LABEL: \"bug_free\" or \"is_bug\"\n",
      "************\n",
      "\n",
      "EXPLANATION:\n",
      "\n",
      "OpenAI invocation parameters: {'model': 'gpt-4', 'temperature': 0.0, 'max_tokens': 256, 'frequency_penalty': 0, 'presence_penalty': 0, 'top_p': 1, 'n': 1, 'timeout': None}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "llm_classify |██        | 1/5 (20.0%) | ⏳ 00:02<00:11 |  2.97s/it"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Snapped 'is_bug' to rail: is_bug\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "llm_classify |████      | 2/5 (40.0%) | ⏳ 00:04<00:06 |  2.07s/it "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Snapped 'is_bug' to rail: is_bug\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "llm_classify |████████  | 4/5 (80.0%) | ⏳ 00:05<00:00 |  1.06it/s "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Snapped 'is_bug' to rail: is_bug\n",
      "- Snapped 'bug_free' to rail: bug_free\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "llm_classify |██████████| 5/5 (100.0%) | ⏳ 00:09<00:00 |  2.07s/it"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Snapped 'bug_free' to rail: bug_free\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "llm_classify |██████████| 5/5 (100.0%) | ⏳ 00:10<00:00 |  2.07s/it\n"
     ]
    }
   ],
   "source": [
    "small_df_sample = df.copy().sample(n=5).reset_index(drop=True)\n",
    "relevance_classifications_df = llm_classify(\n",
    "    dataframe=small_df_sample,\n",
    "    template=CODE_FUNCTIONALITY_PROMPT_TEMPLATE,\n",
    "    model=model,\n",
    "    rails=rails,\n",
    "    provide_explanation=True,\n",
    "    verbose=True,\n",
    "    concurrency=20,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "Kz0R9iIO6hCY",
    "outputId": "9413f186-6c65-4f0b-a1a7-23d903c4bd9d"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>coding_instruction</th>\n",
       "      <th>code</th>\n",
       "      <th>label</th>\n",
       "      <th>explanation</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Write a Python program to optimize a given code and make it run faster.</td>\n",
       "      <td>def optimize_code(code):\\n    optimized_code = \"\"\\n    lines = code.splitlines()\\n    indentation_level = 0\\n\\n    for line in lines:\\n        # Remove redundant white space and apply proper indentation\\n        optimized_code += \" \" * indentation_level + line.strip() + \"\\n\"\\n\\n        # Increment/Decrement indentation level \\n        if line.endswith(\":\"):\\n            indentation_level += 4\\n        else:\\n            if line[0] not in [\"#\", \"\"]:\\n                indentation_level -= 4\\n        indentation_level = max(indentation_level, 0) # prevent it going below 0\\n\\n    return optimized_code</td>\n",
       "      <td>is_bug</td>\n",
       "      <td>The instruction asks for a Python program that optimizes a given code to make it run faster. However, the provided code does not perform any optimization to make the code run faster. Instead, it reformats the code by removing redundant white spaces and adjusting indentation. This does not improve the performance of the code, it only makes it more readable. Therefore, the code does not meet the requirements of the instruction.</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Develop a Python program to estimate the value of PI using Leibniz's formula.</td>\n",
       "      <td>def estimate_pi(n_terms: int) -&gt; float:\\n    numerator: float = 4.0\\n    denominator: float = 1.0\\n    operation: float = 1.0\\n    pi: float = 0.0\\n\\n    for _ in range(n_terms):\\n        pi += operation * (numerator / denominator)\\n        denominator += 2.0\\n        operation *= -1.0\\n\\n    return pi\\n\\n\\nif __name__ == \"__main__\":\\n    print(estimate_pi(1000))</td>\n",
       "      <td>bug_free</td>\n",
       "      <td>The provided Python code correctly implements the Leibniz's formula for estimating the value of PI. The function estimate_pi takes an integer n_terms as input, which represents the number of terms in the Leibniz's series to be used for the estimation. The function then initializes four variables: numerator, denominator, operation, and pi. The numerator is always 4.0, the denominator starts at 1.0 and is incremented by 2.0 after each term, the operation alternates between 1.0 and -1.0 to account for the alternating signs in the series, and pi is the running total of the series. The function then enters a loop that runs for n_terms iterations. In each iteration, the function adds the current term (operation * (numerator / denominator)) to pi, increments the denominator by 2.0, and flips the sign of operation. After the loop, the function returns the estimated value of PI. Therefore, the code is bug-free.</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Construct a python script to display the frequency of each words appearing in a document</td>\n",
       "      <td>from collections import Counter\\n \\nwith open('text.txt', 'r') as f:\\n    data = f.read().lower().split()\\n    \\nword_counter = Counter(data)\\n \\n# Print the sorted most common 10 words\\nfor word, count in word_counter.most_common(10):\\n    print('{}: {}'.format(word, count))</td>\n",
       "      <td>bug_free</td>\n",
       "      <td>The provided code correctly opens a text file, reads its content, converts it to lowercase, splits it into words, and counts the frequency of each word using the Counter class from the collections module. It then prints the 10 most common words along with their frequencies. The code is correct and efficient in solving the given instruction, which is to display the frequency of each word appearing in a document. However, it assumes that the file 'text.txt' exists and is in the same directory as the script, and it does not handle punctuation or special characters, which could be considered part of the words. But as per the given instruction, it is not explicitly required to handle these cases.</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Write a machine learning model in Python to predict the classification of the given email.</td>\n",
       "      <td>import pandas as pd\\nfrom sklearn.model_selection import train_test_split\\nfrom sklearn.feature_extraction.text import TfidfVectorizer\\nfrom sklearn.naive_bayes import MultinomialNB\\n\\n# read in the data\\ndf = pd.read_csv('data.csv')\\n\\n# split the data into training and test sets\\nX_train, X_test, y_train, y_test = train_test_split(df['email_text'], df['class'], test_size=0.2)\\n\\n# create the TF-IDF vectorizer and fit it to our training data\\nvectorizer = TfidfVectorizer(min_df=2)\\nX_train = vectorizer.fit_transform(y_train)\\n\\n# create and train the model\\nmodel = MultinomialNB()\\nmodel.fit(X_train, y_train)\\n\\n# predict the classification of the given email\\nemail_text = \"Holiday alert. Hi everyone, we have planned a holiday on 15th August.\"\\nemail_text_transform = vectorizer.transform([email_text])\\nprediction = model.predict(email_text_transform)\\n\\nprint(\"The predicted classification of the email is: {}\".format(prediction[0]))</td>\n",
       "      <td>is_bug</td>\n",
       "      <td>The code is supposed to create a machine learning model to predict the classification of a given email. It reads in data, splits it into training and test sets, creates a TF-IDF vectorizer and fits it to the training data, creates and trains a Multinomial Naive Bayes model, and then uses this model to predict the classification of a given email. However, there is a bug in the code. The TF-IDF vectorizer is fit to 'y_train' which is the target variable, instead of 'X_train' which is the feature variable. The vectorizer should be fit to the email text, not the class labels.</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Using regex, extend the following python code to remove whitespaces from a string.</td>\n",
       "      <td>def remove_spaces(user_string):\\n    '''This function will remove all the spaces from a string'''\\n    user_string = re.sub(r'\\s',' ',user_string)\\n    return user_string</td>\n",
       "      <td>is_bug</td>\n",
       "      <td>The instruction is to remove all the spaces from a string using regex. The provided code does use regex to find spaces in the string, but it replaces them with a space, not remove them. The correct code should replace the spaces with an empty string ('') to effectively remove them. Therefore, the code does not meet the instruction requirements.</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                                           coding_instruction  \\\n",
       "0                     Write a Python program to optimize a given code and make it run faster.   \n",
       "1               Develop a Python program to estimate the value of PI using Leibniz's formula.   \n",
       "2    Construct a python script to display the frequency of each words appearing in a document   \n",
       "3  Write a machine learning model in Python to predict the classification of the given email.   \n",
       "4          Using regex, extend the following python code to remove whitespaces from a string.   \n",
       "\n",
       "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 code  \\\n",
       "0                                                                                                                                                                                                                                                                                                                                                         def optimize_code(code):\\n    optimized_code = \"\"\\n    lines = code.splitlines()\\n    indentation_level = 0\\n\\n    for line in lines:\\n        # Remove redundant white space and apply proper indentation\\n        optimized_code += \" \" * indentation_level + line.strip() + \"\\n\"\\n\\n        # Increment/Decrement indentation level \\n        if line.endswith(\":\"):\\n            indentation_level += 4\\n        else:\\n            if line[0] not in [\"#\", \"\"]:\\n                indentation_level -= 4\\n        indentation_level = max(indentation_level, 0) # prevent it going below 0\\n\\n    return optimized_code   \n",
       "1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       def estimate_pi(n_terms: int) -> float:\\n    numerator: float = 4.0\\n    denominator: float = 1.0\\n    operation: float = 1.0\\n    pi: float = 0.0\\n\\n    for _ in range(n_terms):\\n        pi += operation * (numerator / denominator)\\n        denominator += 2.0\\n        operation *= -1.0\\n\\n    return pi\\n\\n\\nif __name__ == \"__main__\":\\n    print(estimate_pi(1000))   \n",
       "2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                from collections import Counter\\n \\nwith open('text.txt', 'r') as f:\\n    data = f.read().lower().split()\\n    \\nword_counter = Counter(data)\\n \\n# Print the sorted most common 10 words\\nfor word, count in word_counter.most_common(10):\\n    print('{}: {}'.format(word, count))   \n",
       "3  import pandas as pd\\nfrom sklearn.model_selection import train_test_split\\nfrom sklearn.feature_extraction.text import TfidfVectorizer\\nfrom sklearn.naive_bayes import MultinomialNB\\n\\n# read in the data\\ndf = pd.read_csv('data.csv')\\n\\n# split the data into training and test sets\\nX_train, X_test, y_train, y_test = train_test_split(df['email_text'], df['class'], test_size=0.2)\\n\\n# create the TF-IDF vectorizer and fit it to our training data\\nvectorizer = TfidfVectorizer(min_df=2)\\nX_train = vectorizer.fit_transform(y_train)\\n\\n# create and train the model\\nmodel = MultinomialNB()\\nmodel.fit(X_train, y_train)\\n\\n# predict the classification of the given email\\nemail_text = \"Holiday alert. Hi everyone, we have planned a holiday on 15th August.\"\\nemail_text_transform = vectorizer.transform([email_text])\\nprediction = model.predict(email_text_transform)\\n\\nprint(\"The predicted classification of the email is: {}\".format(prediction[0]))   \n",
       "4                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          def remove_spaces(user_string):\\n    '''This function will remove all the spaces from a string'''\\n    user_string = re.sub(r'\\s',' ',user_string)\\n    return user_string   \n",
       "\n",
       "      label  \\\n",
       "0    is_bug   \n",
       "1  bug_free   \n",
       "2  bug_free   \n",
       "3    is_bug   \n",
       "4    is_bug   \n",
       "\n",
       "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           explanation  \n",
       "0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The instruction asks for a Python program that optimizes a given code to make it run faster. However, the provided code does not perform any optimization to make the code run faster. Instead, it reformats the code by removing redundant white spaces and adjusting indentation. This does not improve the performance of the code, it only makes it more readable. Therefore, the code does not meet the requirements of the instruction.  \n",
       "1  The provided Python code correctly implements the Leibniz's formula for estimating the value of PI. The function estimate_pi takes an integer n_terms as input, which represents the number of terms in the Leibniz's series to be used for the estimation. The function then initializes four variables: numerator, denominator, operation, and pi. The numerator is always 4.0, the denominator starts at 1.0 and is incremented by 2.0 after each term, the operation alternates between 1.0 and -1.0 to account for the alternating signs in the series, and pi is the running total of the series. The function then enters a loop that runs for n_terms iterations. In each iteration, the function adds the current term (operation * (numerator / denominator)) to pi, increments the denominator by 2.0, and flips the sign of operation. After the loop, the function returns the estimated value of PI. Therefore, the code is bug-free.  \n",
       "2                                                                                                                                                                                                                         The provided code correctly opens a text file, reads its content, converts it to lowercase, splits it into words, and counts the frequency of each word using the Counter class from the collections module. It then prints the 10 most common words along with their frequencies. The code is correct and efficient in solving the given instruction, which is to display the frequency of each word appearing in a document. However, it assumes that the file 'text.txt' exists and is in the same directory as the script, and it does not handle punctuation or special characters, which could be considered part of the words. But as per the given instruction, it is not explicitly required to handle these cases.  \n",
       "3                                                                                                                                                                                                                                                                                                                                                   The code is supposed to create a machine learning model to predict the classification of a given email. It reads in data, splits it into training and test sets, creates a TF-IDF vectorizer and fits it to the training data, creates and trains a Multinomial Naive Bayes model, and then uses this model to predict the classification of a given email. However, there is a bug in the code. The TF-IDF vectorizer is fit to 'y_train' which is the target variable, instead of 'X_train' which is the feature variable. The vectorizer should be fit to the email text, not the class labels.  \n",
       "4                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           The instruction is to remove all the spaces from a string using regex. The provided code does use regex to find spaces in the string, but it replaces them with a space, not remove them. The correct code should replace the spaces with an empty string ('') to effectively remove them. Therefore, the code does not meet the instruction requirements.  "
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's view the data\n",
    "merged_df = pd.merge(\n",
    "    small_df_sample, relevance_classifications_df, left_index=True, right_index=True\n",
    ")\n",
    "merged_df[[\"coding_instruction\", \"code\", \"label\", \"explanation\"]].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cHNsvloA6hCZ"
   },
   "source": [
    "## LLM Evals: code functionality Classifications GPT-3.5 Turbo\n",
    "Run Code functionality against a subset of the data using GPT-3.5. GPT-3.5 can significantly speed up the classification process. However there are tradeoffs as  we will see below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "jiQ9LvpU6hCZ",
    "outputId": "6054cdec-f39b-406c-870b-47cd296e56c9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The `model_name` field is deprecated. Use `model` instead.                 This will be removed in a future release.\n"
     ]
    }
   ],
   "source": [
    "model = OpenAIModel(model_name=\"gpt-3.5-turbo\", temperature=0.0, request_timeout=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qn7yl3yZ6hCZ"
   },
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 49,
     "referenced_widgets": [
      "62fd28d79b6d4bae912756a47d1450f2",
      "be64e987f1a547bdb9196b30bae0c2a2",
      "d0bc41ba95514e56b13bb6da23c26bd3",
      "19d2b7ed9b3949adbf9430b40c690800",
      "a78025bd35c84f3793772fd38872bbf3",
      "ff7320e39af3418483200597313e3a9f",
      "e5e348e67d674c77bf5b33643b2ae9ee",
      "efbd10c59abd49e0becbb8e17c6c046f",
      "dc58c35b2e554e0aa0689e3eb8c36e75",
      "dafe7d73cdb54b52a74596dd8d07ef2d",
      "60d5450863e64e36975beda2392ef80a"
     ]
    },
    "id": "uPSGto_B6hCZ",
    "outputId": "ef0454b7-6d6d-47ac-f73c-d2d3a3322565"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "llm_classify |██████████| 50/50 (100.0%) | ⏳ 00:10<00:00 |  4.59it/s\n"
     ]
    }
   ],
   "source": [
    "rails = list(CODE_FUNCTIONALITY_PROMPT_RAILS_MAP.values())\n",
    "relevance_classifications = llm_classify(\n",
    "    dataframe=df,\n",
    "    template=CODE_FUNCTIONALITY_PROMPT_TEMPLATE,\n",
    "    model=model,\n",
    "    rails=rails,\n",
    "    concurrency=20,\n",
    ")[\"label\"].tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 651
    },
    "id": "V6L35oYA6hCa",
    "outputId": "c147f626-389b-4356-bbb4-6f5a50a83902"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "    bug_free       0.95      0.68      0.79        31\n",
      "      is_bug       0.64      0.95      0.77        19\n",
      "\n",
      "    accuracy                           0.78        50\n",
      "   macro avg       0.80      0.81      0.78        50\n",
      "weighted avg       0.84      0.78      0.78        50\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Axes: title={'center': 'Confusion Matrix (Normalized)'}, xlabel='Predicted Classes', ylabel='Actual Classes'>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "true_labels = df[\"is_well_coded\"].map(CODE_FUNCTIONALITY_PROMPT_RAILS_MAP).tolist()\n",
    "\n",
    "print(classification_report(true_labels, relevance_classifications, labels=rails))\n",
    "confusion_matrix = ConfusionMatrix(\n",
    "    actual_vector=true_labels, predict_vector=relevance_classifications, classes=rails\n",
    ")\n",
    "confusion_matrix.plot(\n",
    "    cmap=plt.colormaps[\"Blues\"],\n",
    "    number_label=True,\n",
    "    normalized=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zCu7LB4z6hCa"
   },
   "source": [
    "## Preview: Running with GPT-4 Turbo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 67,
     "referenced_widgets": [
      "eaf0c8354fc24e4aa228525639793107",
      "8499388789c04cf19e29279e9bc9c468",
      "6bfc17ec2fcd4cd4b2d250743590ca19",
      "554fa6afa4144418b9e7ae200ad12b91",
      "bb8d73f1129146c9809dd05ec848fb49",
      "14b484f8c5b84a248cfd6c7e584bb182",
      "4124a8afe45246fd811064e63a55fd6d",
      "34cdb200856f42f7bf6317022bc5b0f5",
      "89c44f8d9ad54370b75eacd7e83a4a70",
      "2ce2cdff3299422889b49b5107071a7b",
      "6490726f2b024d1d8bbedc36adbd7aa6"
     ]
    },
    "id": "jTN1nIqP6hCa",
    "outputId": "7aa1f761-01c3-4675-dc5d-3074ca767d2b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The `model_name` field is deprecated. Use `model` instead.                 This will be removed in a future release.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "llm_classify |██████████| 50/50 (100.0%) | ⏳ 00:12<00:00 |  4.16it/s\n"
     ]
    }
   ],
   "source": [
    "model = OpenAIModel(model_name=\"gpt-4-1106-preview\")\n",
    "classifications = llm_classify(\n",
    "    dataframe=df,\n",
    "    template=CODE_FUNCTIONALITY_PROMPT_TEMPLATE,\n",
    "    model=model,\n",
    "    rails=list(CODE_FUNCTIONALITY_PROMPT_RAILS_MAP.values()),\n",
    "    concurrency=20,\n",
    ")[\"label\"].tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 651
    },
    "id": "dpaZ71bK6hCb",
    "outputId": "e77451db-27dc-48c3-b265-d7b58c0478e3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "    bug_free       1.00      0.77      0.87        31\n",
      "      is_bug       0.73      1.00      0.84        19\n",
      "\n",
      "    accuracy                           0.86        50\n",
      "   macro avg       0.87      0.89      0.86        50\n",
      "weighted avg       0.90      0.86      0.86        50\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Axes: title={'center': 'Confusion Matrix (Normalized)'}, xlabel='Predicted Classes', ylabel='Actual Classes'>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "true_labels = df[\"is_well_coded\"].map(CODE_FUNCTIONALITY_PROMPT_RAILS_MAP).tolist()\n",
    "\n",
    "print(classification_report(true_labels, classifications, labels=rails))\n",
    "confusion_matrix = ConfusionMatrix(\n",
    "    actual_vector=true_labels, predict_vector=classifications, classes=rails\n",
    ")\n",
    "confusion_matrix.plot(\n",
    "    cmap=plt.colormaps[\"Blues\"],\n",
    "    number_label=True,\n",
    "    normalized=True,\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "0d06c9bac593459e8b4349697b60fd45": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "14b484f8c5b84a248cfd6c7e584bb182": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "19d2b7ed9b3949adbf9430b40c690800": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_dafe7d73cdb54b52a74596dd8d07ef2d",
      "placeholder": "​",
      "style": "IPY_MODEL_60d5450863e64e36975beda2392ef80a",
      "value": " 50/50 (100.0%) | ⏳ 00:10&lt;00:00 |  3.61it/s"
     }
    },
    "1f7c7ce2ea874835986c9988bc062d82": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_bb5911202039461b98517aba47f7e656",
       "IPY_MODEL_3357650b34ed48848c6aec68957a9654",
       "IPY_MODEL_5b85cf639b5c4a0cb5e4acff52a58ae8"
      ],
      "layout": "IPY_MODEL_b5440442ff814c69ab5409ec55b16a4e"
     }
    },
    "2ce2cdff3299422889b49b5107071a7b": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "2eefae02445a4b1e9aad8fdc47a63572": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "3357650b34ed48848c6aec68957a9654": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_6f96f9c08c6742429e31e35b5b5e9c45",
      "max": 5,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_861dc30d89d846c6a6f5c1b5398b877c",
      "value": 5
     }
    },
    "34cdb200856f42f7bf6317022bc5b0f5": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "34e87b1773004b83ae4f227a2ec4e504": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_8b4a5af6f76d431d8570e7400f8086fd",
      "placeholder": "​",
      "style": "IPY_MODEL_a9933a0bab7f496fa2527f1abd4f2807",
      "value": "llm_classify "
     }
    },
    "4124a8afe45246fd811064e63a55fd6d": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "554fa6afa4144418b9e7ae200ad12b91": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_2ce2cdff3299422889b49b5107071a7b",
      "placeholder": "​",
      "style": "IPY_MODEL_6490726f2b024d1d8bbedc36adbd7aa6",
      "value": " 50/50 (100.0%) | ⏳ 00:10&lt;00:00 |  4.06it/s"
     }
    },
    "568d5c22695a4108b3b0c27119cbf97e": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "5b85cf639b5c4a0cb5e4acff52a58ae8": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_90253079c26747df99af818a9edabf36",
      "placeholder": "​",
      "style": "IPY_MODEL_e8071c5ea332447c894cd34bee283ab2",
      "value": " 5/5 (100.0%) | ⏳ 00:09&lt;00:00 |  1.08it/s"
     }
    },
    "5ccf1ab7cc164b6cb0c12b99dbd526e1": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "60d5450863e64e36975beda2392ef80a": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "62fd28d79b6d4bae912756a47d1450f2": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_be64e987f1a547bdb9196b30bae0c2a2",
       "IPY_MODEL_d0bc41ba95514e56b13bb6da23c26bd3",
       "IPY_MODEL_19d2b7ed9b3949adbf9430b40c690800"
      ],
      "layout": "IPY_MODEL_a78025bd35c84f3793772fd38872bbf3"
     }
    },
    "6490726f2b024d1d8bbedc36adbd7aa6": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "6bfc17ec2fcd4cd4b2d250743590ca19": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_34cdb200856f42f7bf6317022bc5b0f5",
      "max": 50,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_89c44f8d9ad54370b75eacd7e83a4a70",
      "value": 50
     }
    },
    "6f96f9c08c6742429e31e35b5b5e9c45": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "8499388789c04cf19e29279e9bc9c468": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_14b484f8c5b84a248cfd6c7e584bb182",
      "placeholder": "​",
      "style": "IPY_MODEL_4124a8afe45246fd811064e63a55fd6d",
      "value": "llm_classify "
     }
    },
    "861dc30d89d846c6a6f5c1b5398b877c": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "8763982494d64e97bf50204d4b8beca3": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_34e87b1773004b83ae4f227a2ec4e504",
       "IPY_MODEL_b5914f9bde894147a126f2552c68212c",
       "IPY_MODEL_a508ddd770e44356a773d94ab8fcf977"
      ],
      "layout": "IPY_MODEL_bb44d964d93642b9946253033c3d9e94"
     }
    },
    "89c44f8d9ad54370b75eacd7e83a4a70": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "8b4a5af6f76d431d8570e7400f8086fd": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "90253079c26747df99af818a9edabf36": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "a508ddd770e44356a773d94ab8fcf977": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_568d5c22695a4108b3b0c27119cbf97e",
      "placeholder": "​",
      "style": "IPY_MODEL_f55ce1255e3f4dc6aab23b448a5c7574",
      "value": " 50/50 (100.0%) | ⏳ 00:33&lt;00:00 |  7.50it/s"
     }
    },
    "a78025bd35c84f3793772fd38872bbf3": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "a9933a0bab7f496fa2527f1abd4f2807": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "b5440442ff814c69ab5409ec55b16a4e": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "b5914f9bde894147a126f2552c68212c": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_2eefae02445a4b1e9aad8fdc47a63572",
      "max": 50,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_ca3b583f7f5845f3b0cf197ac1b63976",
      "value": 50
     }
    },
    "bb44d964d93642b9946253033c3d9e94": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "bb5911202039461b98517aba47f7e656": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_0d06c9bac593459e8b4349697b60fd45",
      "placeholder": "​",
      "style": "IPY_MODEL_5ccf1ab7cc164b6cb0c12b99dbd526e1",
      "value": "llm_classify "
     }
    },
    "bb8d73f1129146c9809dd05ec848fb49": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "be64e987f1a547bdb9196b30bae0c2a2": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_ff7320e39af3418483200597313e3a9f",
      "placeholder": "​",
      "style": "IPY_MODEL_e5e348e67d674c77bf5b33643b2ae9ee",
      "value": "llm_classify "
     }
    },
    "ca3b583f7f5845f3b0cf197ac1b63976": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "d0bc41ba95514e56b13bb6da23c26bd3": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_efbd10c59abd49e0becbb8e17c6c046f",
      "max": 50,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_dc58c35b2e554e0aa0689e3eb8c36e75",
      "value": 50
     }
    },
    "dafe7d73cdb54b52a74596dd8d07ef2d": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "dc58c35b2e554e0aa0689e3eb8c36e75": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "e5e348e67d674c77bf5b33643b2ae9ee": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "e8071c5ea332447c894cd34bee283ab2": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "eaf0c8354fc24e4aa228525639793107": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_8499388789c04cf19e29279e9bc9c468",
       "IPY_MODEL_6bfc17ec2fcd4cd4b2d250743590ca19",
       "IPY_MODEL_554fa6afa4144418b9e7ae200ad12b91"
      ],
      "layout": "IPY_MODEL_bb8d73f1129146c9809dd05ec848fb49"
     }
    },
    "efbd10c59abd49e0becbb8e17c6c046f": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "f55ce1255e3f4dc6aab23b448a5c7574": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "ff7320e39af3418483200597313e3a9f": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
